package com.zxy.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.zxy.mapper.SystemMapper;
import com.zxy.pojo.dto.DictTypeQueryVO;
import com.zxy.pojo.entity.DictType;
import com.zxy.pojo.entity.SysDept;
import com.zxy.pojo.entity.SysNotice;
import com.zxy.pojo.vo.DictTypePageResponseVO;
import com.zxy.service.SystemService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.stream.Collectors;

@Service
public class SystemServiceImpl extends ServiceImpl<SystemMapper, DictType> implements SystemService {
    @Autowired
    private SystemMapper systemMapper;



    // 时间格式器：匹配请求中的时间字符串格式（yyyy-MM-dd HH:mm:ss）
    private static final DateTimeFormatter TIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

    @Override
    public DictTypePageResponseVO getDictTypePage(DictTypeQueryVO queryVO) {
        // 1. 构建分页对象（MyBatis-Plus的Page，pageNum从1开始）
        Page<DictType> page = new Page<>(queryVO.getPageNum(), queryVO.getPageSize());

        // 2. 构建多条件查询器（QueryWrapper）
        QueryWrapper<DictType> queryWrapper = new QueryWrapper<>();

        // 2.1 字典名称：模糊查询（若参数不为空）
        if (StringUtils.hasText(queryVO.getDictName())) {
            queryWrapper.like("dict_name", queryVO.getDictName());
        }

        // 2.2 字典类型编码：精确查询（若参数不为空）
        if (StringUtils.hasText(queryVO.getDictType())) {
            queryWrapper.eq("dict_type", queryVO.getDictType());
        }

        // 2.3 状态：精确查询（若参数不为空）
        if (StringUtils.hasText(queryVO.getStatus())) {
            queryWrapper.eq("status", queryVO.getStatus());
        }

        // 2.4 时间范围：创建时间 between beginTime and endTime（若参数不为空）
        DictTypeQueryVO.TimeParam timeParam = queryVO.getParams();
        if (timeParam != null) {
            // 开始时间（转换为LocalDateTime）
            if (StringUtils.hasText(timeParam.getBeginTime())) {
                LocalDateTime beginTime = LocalDateTime.parse(timeParam.getBeginTime(), TIME_FORMATTER);
                queryWrapper.ge("create_time", beginTime); // >= 开始时间
            }
            // 结束时间（转换为LocalDateTime）
            if (StringUtils.hasText(timeParam.getEndTime())) {
                LocalDateTime endTime = LocalDateTime.parse(timeParam.getEndTime(), TIME_FORMATTER);
                queryWrapper.le("create_time", endTime); // <= 结束时间
            }
        }

        // 2.5 排序：按创建时间降序（最新的在前，可选，根据需求调整）
       // queryWrapper.orderByDesc("create_time");

        // 3. 执行分页查询（MyBatis-Plus的page方法，自动返回分页结果）
        Page<DictType> resultPage = baseMapper.selectPage(page, queryWrapper);

        // 4. 封装响应VO（总记录数+当前页数据）
        return DictTypePageResponseVO.success(
                resultPage.getTotal(), // 总记录数
                resultPage.getRecords() // 当前页数据列表
        );
    }



    @Override
    public List<SysNotice> getNoticeListByReadStatus(Integer readStatus) {
        // 使用专门的通知查询方法，而不是QueryWrapper
        return systemMapper.selectNoticeListByReadStatus(readStatus);
    }


    /**
     * 递归查找子部门
     * @param parentId 父部门ID（当前部门的ID）
     * @param allDepts 所有部门列表（避免重复查询数据库）
     * @return 子部门列表（含嵌套子部门）
     */
    private List<SysDept> findChildren(Long parentId, List<SysDept> allDepts) {
        // 3.1 筛选当前父部门的直接子部门（parentId=传入的parentId）
        List<SysDept> children = allDepts.stream()
                .filter(dept -> dept.getParentId().equals(parentId))
                .collect(Collectors.toList());

        // 3.2 递归给每个子部门组装它的子部门（若有）
        if (!CollectionUtils.isEmpty(children)) {
            for (SysDept child : children) {
                List<SysDept> grandChildren = findChildren(child.getId(), allDepts);
                // 只有当子节点不为空时才添加到children中
                if (!grandChildren.isEmpty()) {
                    child.setChildren(grandChildren);
                }
            }
        }

        // 确保返回非空列表，避免 children 为 null
        return children;
    }

    @Override
    public List<SysDept> getDeptTreeSelect() {
        // 1. 查询所有正常状态的部门（筛选status=0，避免禁用部门）
        List<SysDept> allDepts = systemMapper.selectDeptList().stream()
                .filter(dept -> "0".equals(dept.getStatus()))
                .sorted((d1, d2) -> d1.getSort().compareTo(d2.getSort()))
                .collect(Collectors.toList());

        // 2. 筛选顶级部门（parentId=0）
        List<SysDept> topDepts = allDepts.stream()
                .filter(dept -> dept.getParentId().equals(0L)) // 顶级部门父ID为0
                .collect(Collectors.toList());

        // 3. 递归给每个顶级部门组装子部门
        for (SysDept topDept : topDepts) {
            List<SysDept> children = findChildren(topDept.getId(), allDepts);
            // 只有当子节点不为空时才添加到children中
            if (!children.isEmpty()) {
                topDept.setChildren(children);
            }
        }

        // 4. 过滤掉没有子节点的顶级部门
        return topDepts.stream()
                .filter(dept -> dept.getChildren() != null && dept.getChildren().size() > 0)
                .collect(Collectors.toList());
    }
}
